﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using Zzva.DomainObject;
using Zzva.Common;
using System.Collections;
using Zzva.ESB;


namespace Zzva.DomainObjectReg
{
    public class TRegDirITCompany: TRegDirBase 
    {


        private static TRegDirITCompany mvarRegDirITCompany;

        public void Delete()
        {
            try
            {
                TDirBase lCurDir;
                Collection<TDirBase> lCurListDir;
                int lIdAfterDelete;

                lCurListDir = GetCurList();
                lCurDir = GetCurItem();

                lIdAfterDelete = GetIdAfterDelete(lCurDir, lCurListDir);

                if (lIdAfterDelete == -1) { throw (new CommonException("Нет текущего элемента в коллекции")); }

                TDirITCompanyBase lDirITCompanyBase = (TDirITCompanyBase)lCurDir;
                Esb.DeleteITCompany(ref lDirITCompanyBase);
                TDirITCompanyNull lDirITCompanyNull = (TDirITCompanyNull)lDirITCompanyBase;
                Collection<TDirITCompany> lListDir = Esb.GetListITCompany();

                Collection<TDirBase> lListDirBase = new Collection<TDirBase>();
                foreach (TDirITCompany h in lListDir) { lListDirBase.Add((TDirBase)h); }

                TDirBase lCurItem;
                if (lIdAfterDelete > 0) { lCurItem = GetItemById(lIdAfterDelete, lListDirBase); }
                else if (lIdAfterDelete == 0) { lCurItem = null; }
                else if (lIdAfterDelete == -1) { throw (new CommonException("Нет текущего элемента в коллекции")); }
                else { throw (new CommonException("Нет значения возврата для GetIdAfterDelete")); }

                mvarFullListDir = lListDirBase;
                mvarCurItem = lCurItem;

                ////
                mvarFlgSinhroCurListAndCurState = false;


                //дальше здесь событие что обновлено
                FireEventUpdateList(EventArgs.Empty);
            }
            catch (Exception e1) { throw e1; }
            finally { }
        }


        //Редактирует текущую элемент справочника, на вход объект TDirITCompanyNew  с новыми знвчениями текщей записи
        public void Edit(TDirITCompanyNew pDir)
        {
            try
            {
                TDirBase lCurDir;

                //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                //Тут бы желательно открыть транзакцию

                lCurDir = this.GetCurItem();
                lCurDir.Obozn = pDir.Obozn;
                lCurDir.Naim = pDir.Naim;


                TDirITCompanyBase lDirITCompanyBase = (TDirITCompanyBase)lCurDir;
                Esb.SaveITCompany(ref lDirITCompanyBase);
                TDirITCompany lDirITCompany = (TDirITCompany)lDirITCompanyBase;
                Collection<TDirITCompany> lListDir = Esb.GetListITCompany();

                Collection<TDirBase> lListDirBase = new Collection<TDirBase>();
                foreach (TDirITCompany h in lListDir)
                {
                    lListDirBase.Add((TDirBase)h);
                }

                TDirBase lCurItem;
                lCurItem = GetItemById(lDirITCompany.Id, lListDirBase);

                mvarFullListDir = lListDirBase;
                mvarCurItem = lCurItem;

                ////
                mvarFlgSinhroCurListAndCurState = false;


                //дальше здесь событие что обновлено
                FireEventUpdateList(EventArgs.Empty);
            }
            catch (Exception e1) { throw e1; }
            finally { }
        }



        //Добавляет элемент справочника и делает его текущим
        public void Add(TDirITCompanyNew pDir)
        {
            try
            {
                TDirITCompanyBase lDirITCompanyBase = (TDirITCompanyBase)pDir;
                Esb.SaveITCompany(ref lDirITCompanyBase);
                TDirITCompany lDirITCompany = (TDirITCompany)lDirITCompanyBase;
                Collection<TDirITCompany> lListDir = Esb.GetListITCompany();


                Collection<TDirBase> lListDirBase = new Collection<TDirBase>();
                foreach (TDirITCompany h in lListDir)
                {
                    lListDirBase.Add((TDirBase)h);
                }


                TDirBase lCurItem;
                lCurItem = GetItemById(lDirITCompany.Id, lListDirBase);

                mvarFullListDir = lListDirBase;
                mvarCurItem = lCurItem;


                ////
                mvarFlgSinhroCurListAndCurState = false;


                //дальше здесь событие что обновлено
                FireEventUpdateList(EventArgs.Empty);

            }

            catch (Exception e1) { throw e1; }
            finally { }
        }






































































        #region (Конструктор, Singeleton)...

        //Возвращает единственный экземпляр Контроллера себя любимого
        public static TRegDirITCompany GetObject()
        {
            try
            {

                //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
                //Убираем сингелетон то выяснения причин сбоя при повторном вызове
                ////if (mvarRegDirITCompany == null)
                ////{
                    Collection<TDirITCompany> lListITCompany;
                    lListITCompany = TEsb.GetEsb().GetListITCompany();

                    Collection<TDirBase> lListDirBase = new Collection<TDirBase>();
                    foreach (TDirITCompany h in lListITCompany){lListDirBase.Add((TDirBase)h);}

                    mvarRegDirITCompany = new TRegDirITCompany(lListDirBase);
                ////}


                return mvarRegDirITCompany;
            }
            catch (Exception e) { throw e; }
            finally { }
        }



        protected TRegDirITCompany(Collection<TDirBase> pFullListDir)
            : base(pFullListDir)
        {
            try { }
            catch (Exception e) { throw e; }
            finally { }
        }



        #endregion








        public override string Title
        { get { return "Справочник. ИТ Компании"; } }






 














////        //Проверяет наличие функции у делегата
////        public bool CheckEventUpdateListIsNull()
////        {
////            if (EventUpdateList == null) { return true; }
////            else { return false; }
////        }



////        //Проверяет наличие функции у делегата
////        public bool CheckEventFindDirIsNull()
////        {
////            if (EventFindDir == null) { return true; }
////            else { return false; }
////        }



////        protected virtual void FireEventFindDir(TDirFindEventArgs pDirFindEventArgs)
////        {
////            try { if (EventFindDir != null) EventFindDir(this, pDirFindEventArgs); }
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }


////       protected virtual void FireEventUpdateList(EventArgs pUpdateListEventArgs)
////        {
////            try{if (EventUpdateList != null) EventUpdateList(this, pUpdateListEventArgs);}
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }



////        //Возвращает текущий элемент
////        public TDirITCompany GetCurItem()
////        { return mvarCurItem; }




////        //Возвращает текущее представление справочника с учетом фильта и сортировки
////        private Collection<TDirITCompany> GetCurList()
////        {
////            try
////            {
////                Collection<TDirITCompany> lCurList;
////                lCurList = new Collection<TDirITCompany>();
////
////
////                #region (Примеры использования делегата public delegate TResult Func<T, TResult>(T arg)) в операциях LINQ
////                //1 метод - делегат внешняя функция
////                ////Func<TDirITCompany, string> lSelector = TestDelegateFuncGetSelector;
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////
////                //2 метод - делегат внешняя функция
////                ////Func<TDirITCompany, string> lSelector;
////                ////lSelector  = TestDelegateFuncGetSelector;
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////
////                //3 метод с использованием анонимной фукнкции
////                ////Func<TDirITCompany, string> lSelector;
////                ////lSelector = delegate(TDirITCompany lDirITCompany)
////                ////{
////                ////    return lDirITCompany.Obozn;
////                ////};
////                ////
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////
////
////                //4 метод с использованием анонимной фукнкции
////                ////Func<TDirITCompany, string> lSelector = delegate(TDirITCompany lDirITCompany)
////                ////{
////                ////    return lDirITCompany.Obozn;
////                ////};
////                ////
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////
////                ////5 метод с использованием лямбада выражения в описании функции
////                ////Func<TDirITCompany, string> lSelector = h => h.Obozn;
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////
////                ////6 метод с использованием лямбада выражения в описании функции
////                ////Func<TDirITCompany, string> lSelector;
////                ////lSelector = h => h.Obozn;
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////
////                ////7метод с использованием лямбада выражения в описании функции
////                ////Func<TDirITCompany, string> lSelector;
////                ////lSelector = h =>
////                ////{
////                ////    string k = h.Obozn; 
////                ////    return k;
////                ////};
////                ////var hhh = mvarListDir.OrderBy(lSelector);
////
////                ////8метод с использованием лямбада выражения в описании функции
////                ////var hhh = mvarListDir.OrderBy(h => h.Obozn);
////                #endregion
////
////
////                IEnumerable<TDirITCompany> hhh;
////
////
////
////                ////                //Sort
////               ////                Func<TDirITCompany, string> lSelector;
////                ////                lSelector = null;
////                ////                switch (mvarSortValue.FieldObozn)
////                ////                {
////                ////                    case "Id":
////                ////                        lSelector = h => { return h.Id.ToString(); };
////                ////                        break;
////                ////                    case "Obozn":
////                ////                        lSelector = h => { return h.Obozn; };
////                ////                        break;
////                ////                    case "Naim":
////                ////                        lSelector = h => { return h.Naim + "," + h.Obozn; };
////                ////                        break;
////                ////                    default:
////                ////                        throw (new CommonException("Нет такого поля"));
////                ////                }
////                ////
////                ////                if (mvarSortValue.SortType == ESortType.OrderForward){hhh = mvarListDir.OrderBy(lSelector);}
////                ////                else if ((mvarSortValue.SortType == ESortType.OrderBackward)){hhh = mvarListDir.OrderByDescending(lSelector);}
////                ////                else { throw (new CommonException("Нет типа сортировки")); }
////
////
////
////                //Sort
////                Func<TDirITCompany, object> lSelector;
////                lSelector = h => { return h.GetAttrib(mvarSortValue.FieldObozn); };
////                if (mvarSortValue.SortType == ESortType.OrderForward)
////                {
////                    ////hhh = mvarListDir.OrderBy(h => h.GetAttrib(mvarSortValue.FieldObozn));
////                    hhh = mvarListDir.OrderBy(lSelector);
////                }
////                else if ((mvarSortValue.SortType == ESortType.OrderBackward))
////                {
////                    ////hhh = mvarListDir.OrderByDescending(h => h.GetAttrib(mvarSortValue.FieldObozn));
////                    hhh = mvarListDir.OrderByDescending(lSelector);
////                }
////                else { throw (new CommonException("Нет типа сортировки")); }
////
////
////
////                //Filter
////                //готовим делегата условия
////                Func<TDirITCompany, bool> lPredicate;
////                lPredicate = null;
////
////                if (mvarListFilter.Count != 0) //Есть фильтр
////                {
////                    foreach (TFilterValue k in mvarListFilter)
////                    {
////                        switch (k.FieldObozn)
////                        {
////                            case "Id":
////                                lPredicate = d => d.Id.ToString().ToLower().Contains(k.FilterTemplate.ToLower());
////                                break;
////                            case "Obozn":
////                                lPredicate = d => d.Obozn.ToLower().Contains(k.FilterTemplate.ToLower());
////                                break;
////                            case "Naim":
////                                lPredicate = d => d.Naim.ToLower().Contains(k.FilterTemplate.ToLower());
////                                break;
////                            default:
////                                throw (new CommonException("Нет такого поля"));
////                        }
////                        hhh = hhh.Where(lPredicate).ToList();
////                    }
////                }
////
////                foreach (TDirITCompany h in hhh) { lCurList.Add(h); }
////
////                return lCurList;
////            }
////            catch (Exception e) { throw e; }
////            finally { }
////        }


////       public object GetCurListView()
////       {
////           try
////           {
////               Collection<TDirITCompany> lCurrentList = GetCurList();
////
////                var hhh = lCurrentList.Select(p => new
////                {
////                    Id = p.Id,
////                    Обозначение = p.Obozn,
////                    Наименование = p.Naim,
////                }).ToList();
////                return hhh;
////            }
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }



////       //Возвращает первый элемент
////        private TDirITCompany GetFirstItem(Collection<TDirITCompany> pListDir)
////        {
////            try
////            {
////                TDirITCompany lDirITCompany;
////
////                ////lDirITCompany = pListDir.First();
////                lDirITCompany = pListDir.FirstOrDefault();
////                return lDirITCompany;
////            }
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }


////        public void Sort(TSortValue pSortValue)
////        {
////            try
////            {
////
////                //Изменяем алиас на код поля
////                TSortValue lSortValue;
////                string lFieldObozn;
////                lFieldObozn = GetColumnOboznByAlias(pSortValue.FieldObozn);
////                if (lFieldObozn == "") { throw (new CommonException("Нет обозначения по алиасу")); }
////                lSortValue = new TSortValue(lFieldObozn, pSortValue.SortType);
////
////
////                ////mvarSortValue = pSortValue;
////                mvarSortValue = lSortValue;
////
////
////                Collection<TDirITCompany> lCurList;
////                lCurList = GetCurList();
////
////                TDirITCompany lFirstItem;
////                lFirstItem = GetFirstItem(lCurList);
////                mvarCurItem = lFirstItem;
////
////                //дальше здесь событие что обновлено
////                if (EventUpdateList != null) EventUpdateList(this, EventArgs.Empty);
////
////
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }



        #region Filter...

////        public void FilterAdd(TFilterValue pFilterValue)
////        {
////            try
////            {
////                if (pFilterValue.FilterTemplate.Trim() != "")//Фильтр с пустой строкой игнорируются
////                {
////                    //Изменяем алиас на код поля
////                    TFilterValue lFilterValue;
////                    string lFieldObozn;
////                    lFieldObozn = GetColumnOboznByAlias(pFilterValue.FieldObozn);
////                    if (lFieldObozn == "") { throw (new CommonException("Нет обозначения по алиасу")); }
////                    lFilterValue = new TFilterValue(lFieldObozn, pFilterValue.FilterTemplate);
////
////
////                    ////mvarListFilter.Add(pFilterValue);
////                    mvarListFilter.Add(lFilterValue);
////
////
////                    Collection<TDirITCompany> lCurList;
////                    lCurList = GetCurList();
////
////                    TDirITCompany lFirstItem;
////                    lFirstItem = GetFirstItem(lCurList);
////                    mvarCurItem = lFirstItem;
////
////                    //дальше здесь событие что обновлено
////                    if (EventUpdateList != null) EventUpdateList(this, EventArgs.Empty);
////                }
////            }
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }


////        public void FilterDel()
////        {
////            try
////            {
////                mvarListFilter.Clear();
////
////                Collection<TDirITCompany> lCurList;
////                lCurList = GetCurList();
////
////                TDirITCompany lFirstItem;
////                lFirstItem = GetFirstItem(lCurList);
////                mvarCurItem = lFirstItem;
////
////                //дальше здесь событие что обновлено
////                if (EventUpdateList != null) EventUpdateList(this, EventArgs.Empty);
////            }
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }

        #endregion




 






////       //Возвращает текущий элемент
////        public TDirITCompany GetCurItem()
////        { return mvarCurItem; }




        ////        //Возвращает индекс текущего итема в текущей последовательности
        ////        //если нет текущего итема возвращает -1
        ////        // 0 это превыйэлемент последоватедьности (для справки)
        ////        private int GetCurItemIndex()
        ////        {
        ////            try
        ////            {
        ////                int lIndex;
        ////                int lResult;
        ////                Collection<TDirITCompany> lCurList;
        ////                TDirITCompany lCurItem;
        ////
        ////                lCurItem = GetCurItem();
        ////
        ////                if (lCurItem == null) { lResult = -1; }
        ////                else
        ////                {
        ////                    lCurList = GetCurList();
        ////                    lIndex = lCurList.IndexOf(lCurItem);
        ////                    if (lIndex == -1) { throw (new CommonException("Текущий элемент не найден")); }
        ////                    else { lResult = lIndex; }
        ////                }
        ////
        ////                return lResult;
        ////            }
        ////
        ////            catch (Exception e1) { throw e1; }
        ////            finally { }
        ////        }





        #region Find...

////       //Находит ячейку с заданным критерием в текущем списке и делает ее текущей
////        // Поиск начианется с текущей ячейки вверх списка
////        //Если не находит, остается на текущей ячейке
////        public void FindPrev(TFilterValue lFindValue)
////    {
////            try
////            {
////                TDirITCompany lDirITCompany;
////                Collection<TDirITCompany> lCurList;
////                string lFieldObozn;
////                string lFindTemplate;
////                TDirFindEventArgs lDirFindEventArgs;
////
////                ////lFieldObozn = lFindValue.FieldObozn;
////                lFieldObozn = GetColumnOboznByAlias(lFindValue.FieldObozn);
////                if (lFieldObozn == "") { throw (new CommonException("Нет такого обозначения по алиасу")); }
////
////
////                lFindTemplate = lFindValue.FilterTemplate;
////
////                if (lFindTemplate == "") { throw (new CommonException("Отсутсвует критерий поиска")); }
////
////                lCurList = GetCurList();
////
////                //готовим делегата условия
////                Func<TDirITCompany, bool> lPredicate;
////                lPredicate = null;
////                switch (lFieldObozn)
////                {
////                    case "Id":
////                        lPredicate = d => d.Id.ToString().ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    case "Obozn":
////                        lPredicate = d => d.Obozn.ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    case "Naim":
////                        lPredicate = d => d.Naim.ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    default:
////                        throw (new CommonException("Нет такого поля"));
////                }
////
////
////                int lCurItemIndex;
////                lCurItemIndex = GetCurItemIndex();
////                if (lCurItemIndex == -1) { lDirFindEventArgs = new TDirFindEventArgs(false, null); }//вообще нет записей -> негде искать
////                else
////                {
////
////                    var hhh = lCurList.Take(lCurItemIndex);// обрезаем снизу от текущей записис
////                    lDirITCompany = hhh.LastOrDefault(lPredicate);
////
////                    if (lDirITCompany != null)
////                    {
////                        mvarCurItem = lDirITCompany;
////                        lDirFindEventArgs = new TDirFindEventArgs(true, (TDirBase)GetCurItem());
////                    }
////                    else { lDirFindEventArgs = new TDirFindEventArgs(false, null); }
////
////                }
////
////                EventFindDir(this, lDirFindEventArgs);
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }




////        //Находит ячейку с заданным критерием в текущем списке и делает ее текущей
////        // Поиск начианется с текущей ячейки вниз списка
////        //Если не находит, остается на текущей ячейке
////        public void FindNext(TFilterValue lFindValue)
////        {
////            try
////            {
////                TDirITCompany lDirITCompany;
////                Collection<TDirITCompany> lCurList;
////                string lFieldObozn;
////                string lFindTemplate;
////                TDirFindEventArgs lDirFindEventArgs;
////
////
////                ////lFieldObozn = lFindValue.FieldObozn;
////                lFieldObozn = GetColumnOboznByAlias(lFindValue.FieldObozn);
////                if (lFieldObozn == "") { throw (new CommonException("Нет такого обозначения по алиасу")); }
////
////
////
////
////                lFindTemplate = lFindValue.FilterTemplate;
////
////
////
////
////
////
////
////
////                if (lFindTemplate == "") { throw (new CommonException("Отсутсвует критерий поиска")); }
////
////                lCurList = GetCurList();
////
////                //готовим делегата условия
////                Func<TDirITCompany, bool> lPredicate;
////                lPredicate = null;
////                switch (lFieldObozn)
////                {
////                    case "Id":
////                        lPredicate = d => d.Id.ToString().ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    case "Obozn":
////                        lPredicate = d => d.Obozn.ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    case "Naim":
////                        lPredicate = d => d.Naim.ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    default:
////                        throw (new CommonException("Нет такого поля"));
////                }
////
////
////                int lCurItemIndex;
////                lCurItemIndex = GetCurItemIndex();
////                if (lCurItemIndex == -1) { lDirFindEventArgs = new TDirFindEventArgs(false, null); }//вообще нет записей -> негде искать
////                else
////                {
////                    var hhh = lCurList.Skip(lCurItemIndex + 1);// обрезаем сверху от текущей записис
////                    lDirITCompany = hhh.FirstOrDefault(lPredicate);
////
////                    if (lDirITCompany != null)
////                    {
////                        mvarCurItem = lDirITCompany;
////                        lDirFindEventArgs = new TDirFindEventArgs(true, (TDirBase)GetCurItem());
////                    }
////                    else { lDirFindEventArgs = new TDirFindEventArgs(false, null); }
////                }
////
////                EventFindDir(this, lDirFindEventArgs);
////
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }


////        //Находит ячейку с заданным критерием в текущем списке и делает ее текущей
////        // Поиск начианется с первой ячейки вниз списка
////        //Если не находит, остается на текущей ячейке
////        public void Find(TFilterValue lFindValue)
////        {
////            try
////            {
////                TDirITCompany lDirITCompany;
////                Collection<TDirITCompany> lCurList;
////                string lFieldObozn;
////                string lFindTemplate;
////                TDirFindEventArgs lDirFindEventArgs;
////
////
////                ////lFieldObozn = lFindValue.FieldObozn;
////                lFieldObozn = GetColumnOboznByAlias(lFindValue.FieldObozn);
////                if (lFieldObozn == "") { throw (new CommonException("Нет такого обозначения по алиасу")); }
////
////
////
////
////                lFindTemplate = lFindValue.FilterTemplate;
////
////                if (lFindTemplate == "") { throw (new CommonException("Отсутсвует критерий поиска")); }
////
////                lCurList = GetCurList();



////                //готовим делегата условия
////                Func<TDirITCompany, bool> lPredicate;
////                lPredicate = null;
////                switch (lFieldObozn)
////                {
////                    case "Id":
////                        lPredicate = d => d.Id.ToString().ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    case "Obozn":
////                        lPredicate = d => d.Obozn.ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    case "Naim":
////                        lPredicate = d => d.Naim.ToLower().Contains(lFindTemplate.ToLower());
////                        break;
////                    default:
////                        throw (new CommonException("Нет такого поля"));
////                }
////
////                lDirITCompany = lCurList.FirstOrDefault(lPredicate);
////
////
////                if (lDirITCompany != null)
////                {
////                    mvarCurItem = lDirITCompany;
////                    lDirFindEventArgs = new TDirFindEventArgs(true, (TDirBase)GetCurItem());
////                }
////                else { lDirFindEventArgs = new TDirFindEventArgs(false, null); }
////
////                EventFindDir(this, lDirFindEventArgs);
////
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }







        #endregion



////       //Возвращает ИД следующего после удаления текущего элемента
////        private int GetIdAfterDelete(TDirITCompany pDir, Collection<TDirITCompany> pListDir)
////        {
////            try
////            {
////                int lIndex;
////                int Result;
////                TDirITCompany lAfterDeleteDir;
////
////                lIndex = pListDir.IndexOf(pDir);
////
////                if (lIndex == -1) { Result = -1; }//нет исходного объекта в коллекции
////                else
////                {
////                    lAfterDeleteDir = pListDir.ElementAtOrDefault(lIndex + 1);
////                    if (lAfterDeleteDir == null)
////                    {
////                        lAfterDeleteDir = pListDir.ElementAtOrDefault(lIndex - 1);
////                        if (lAfterDeleteDir == null) { Result = 0; }//Нет объектов после удаления}
////                        else { Result = lAfterDeleteDir.Id; }//Возвращаем предыдйущий объект}
////                    }
////                    else { Result = lAfterDeleteDir.Id; }//возвращаем следующий объект
////
////                }
////                return Result;
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }





////        //Клиент устанавливает текущую запись в текщем представлении
////        public void SetCurItem(int pId)
////        {
////            try
////            {
////                Collection<TDirITCompany> lCurList;
////                TDirITCompany lCurItem;
////
////                lCurList = GetCurList();
////                lCurItem = lCurList.Single(p => p.Id == pId);
////                mvarCurItem = lCurItem;
////            }
////            catch (Exception e) { throw e; }
////            finally { }
////        }




////        //Возвращает элемент коллекции по значению идентификатора
////        private TDirITCompany GetItemById(int pId, Collection<TDirITCompany> pListDir)
////        {
////            try
////            {
////                TDirITCompany hhh = pListDir.SingleOrDefault(r => r.Id == pId);
////                return hhh;
////            }
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }








 














////        //Удаляет текущую запись
////        public void Delete()
////        {
////            try
////            {
////                TDirITCompany lCurDir;
////                Collection<TDirITCompany> lCurListDir;
////                int lIdAfterDelete;
////
////                lCurListDir = GetCurList();
////                lCurDir = GetCurItem();
////
////                lIdAfterDelete = GetIdAfterDelete(lCurDir, lCurListDir);
////
////                if (lIdAfterDelete == -1) { throw (new CommonException("Нет текущего элемента в коллекции")); }
////
////
////                TDirITCompanyBase lDirITCompanyBase = (TDirITCompanyBase)lCurDir;
////                Esb.DeleteITCompany(ref lDirITCompanyBase);
////                TDirITCompanyNull lDirITCompanyNull = (TDirITCompanyNull)lDirITCompanyBase;
////                Collection<TDirITCompany> lListDir = Esb.GetListITCompany();
////
////
////                TDirITCompany lCurItem;
////
////                if (lIdAfterDelete > 0) { lCurItem = GetItemById(lIdAfterDelete, lListDir); }
////                else if (lIdAfterDelete == 0) { lCurItem = null; }
////                else if (lIdAfterDelete == -1) { throw (new CommonException("Нет текущего элемента в коллекции")); }
////                else { throw (new CommonException("Нет значения возврата для GetIdAfterDelete")); }
////
////
////
////
////                mvarListDir = lListDir;
////                mvarCurItem = lCurItem;
////
////
////                //дальше здесь событие что обновлено
////                if (EventUpdateList != null) EventUpdateList(this, EventArgs.Empty);
////
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }


        //Удаляет текущую запись





////        //Редактирует текущую элемент справочника, на вход объект TDirITCompanyNew  с новыми знвчениями текщей записи
////        public void Edit(TDirITCompanyNew pDir)
////        {
////            try
////            {
////                TDirITCompany lCurDir;
////
////                //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
////                //Тут бы желательно открыть транзакцию
////
////                lCurDir = this.GetCurItem();
////                lCurDir.Obozn = pDir.Obozn;
////                lCurDir.Naim = pDir.Naim;
////
////                TDirITCompanyBase lDirITCompanyBase = (TDirITCompanyBase)lCurDir;
////                Esb.SaveITCompany(ref lDirITCompanyBase);
////                TDirITCompany lDirITCompany = (TDirITCompany)lDirITCompanyBase;
////                Collection<TDirITCompany> lListDir = Esb.GetListITCompany();
////                TDirITCompany lCurItem;
////                lCurItem = GetItemById(lDirITCompany.Id, lListDir);
////
////                mvarListDir = lListDir;
////                mvarCurItem = lCurItem;
////
////
////                //дальше здесь событие что обновлено
////                if (EventUpdateList != null) EventUpdateList(this, EventArgs.Empty);
////
////
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }




////        //Добавляет элемент справочника и делает его текущим
////        public void Add(TDirITCompanyNew pDir)
////        {
////            try
////            {
////                TDirITCompanyBase lDirITCompanyBase = (TDirITCompanyBase)pDir;
////                Esb.SaveITCompany(ref lDirITCompanyBase);
////                TDirITCompany lDirITCompany = (TDirITCompany)lDirITCompanyBase;
////                Collection<TDirITCompany> lListDir = Esb.GetListITCompany();
////                TDirITCompany lCurItem;
////                lCurItem = GetItemById(lDirITCompany.Id, lListDir);
////
////                mvarListDir = lListDir;
////                mvarCurItem = lCurItem;
////
////                //дальше здесь событие что обновлено
////                if (EventUpdateList != null) EventUpdateList(this, EventArgs.Empty);
////
////            }
////
////            catch (Exception e1) { throw e1; }
////            finally { }
////        }

































































































































































 






 



































 














 













        private string TestDelegateFuncGetSelector(TDirITCompany lDirITCompany)
        {

            return lDirITCompany.Obozn;
        }








 






























 





























    }
}
